{
  lib,
  stdenv,
  runCommand,
  newScope,
  fetchFromGitLab,
  makeWrapper,
  symlinkJoin,
  callPackage,
  callPackages,

  adwaita-icon-theme,
  dconf,
  gtk3,
  wxGTK32,
  librsvg,
  cups,
  gsettings-desktop-schemas,
  hicolor-icon-theme,

  unzip,
  jq,

  pname ? "kicad",
  stable ? true,
  testing ? false,
  withNgspice ? !stdenv.hostPlatform.isDarwin,
  libngspice,
  withScripting ? true,
  python3,
  addons ? [ ],
  debug ? false,
  sanitizeAddress ? false,
  sanitizeThreads ? false,
  with3d ? true,
  withI18n ? true,
  srcs ? { },
}:

# `addons`: https://dev-docs.kicad.org/en/addons/
#
# ```nix
# kicad = pkgs.kicad.override {
#   addons = with pkgs.kicadAddons; [ kikit kikit-library ];
# };
# ```

# The `srcs` parameter can be used to override the kicad source code
# and all libraries, which are otherwise inaccessible
# to overlays since most of the kicad build expression has been
# refactored into base.nix, most of the library build expressions have
# been refactored into libraries.nix. Overrides are only applied when
# building `kicad-unstable`. The `srcs` parameter has
# no effect for stable `kicad`. `srcs` takes an attribute set in which
# any of the following attributes are meaningful (though none are
# mandatory): "kicad", "kicadVersion", "symbols", "templates",
# "footprints", "packages3d", and "libVersion". "kicadVersion" and
# "libVersion" should be set to a string with the desired value for
# the version attribute in kicad's `mkDerivation` and the version
# attribute in any of the library's `mkDerivation`, respectively.
# "kicad", "symbols", "templates", "footprints", and "packages3d"
# should be set to an appropriate fetcher (e.g. `fetchFromGitLab`).
# So, for example, a possible overlay for kicad is:
#
# final: prev:

# {
#   kicad-unstable = (prev.kicad-unstable.override {
#     srcs = {
#       kicadVersion = "2020-10-08";
#       kicad = prev.fetchFromGitLab {
#         group = "kicad";
#         owner = "code";
#         repo = "kicad";
#         rev = "fd22fe8e374ce71d57e9f683ba996651aa69fa4e";
#         sha256 = "sha256-F8qugru/jU3DgZSpQXQhRGNFSk0ybFRkpyWb7HAGBdc=";
#       };
#     };
#   });
# }

let
  baseName =
    if testing then
      "kicad-testing"
    else if stable then
      "kicad"
    else
      "kicad-unstable";
  versionsImport = import ./versions.nix;

  # versions.nix does not provide us with version, src and rev. We
  # need to turn this into appropriate fetcher calls.
  kicadSrcFetch = fetchFromGitLab {
    group = "kicad";
    owner = "code";
    repo = "kicad";
    rev = versionsImport.${baseName}.kicadVersion.src.rev;
    sha256 = versionsImport.${baseName}.kicadVersion.src.sha256;
  };

  libSrcFetch =
    name:
    fetchFromGitLab {
      group = "kicad";
      owner = "libraries";
      repo = "kicad-${name}";
      rev = versionsImport.${baseName}.libVersion.libSources.${name}.rev;
      sha256 = versionsImport.${baseName}.libVersion.libSources.${name}.sha256;
    };

  # only override `src` or `version` if building `kicad-unstable` with
  # the appropriate attribute defined in `srcs`.
  srcOverridep = attr: (!stable && builtins.hasAttr attr srcs);

  # use default source and version (as defined in versions.nix) by
  # default, or use the appropriate attribute from `srcs` if building
  # unstable with `srcs` properly defined.
  kicadSrc = if srcOverridep "kicad" then srcs.kicad else kicadSrcFetch;
  kicadVersion =
    if srcOverridep "kicadVersion" then
      srcs.kicadVersion
    else
      versionsImport.${baseName}.kicadVersion.version;

  libSrc = name: if srcOverridep name then srcs.${name} else libSrcFetch name;
  # TODO does it make sense to only have one version for all libs?
  libVersion =
    if srcOverridep "libVersion" then
      srcs.libVersion
    else
      versionsImport.${baseName}.libVersion.version;

  wxGTK = wxGTK32;
  python = python3;
  wxPython = python.pkgs.wxpython;
  addonPath = "addon.zip";
  addonsDrvs = map (pkg: pkg.override { inherit addonPath python3; }) addons;

  addonsJoined =
    runCommand "addonsJoined"
      {
        inherit addonsDrvs;
        nativeBuildInputs = [
          unzip
          jq
        ];
      }
      ''
        mkdir $out

        for pkg in $addonsDrvs; do
          unzip $pkg/addon.zip -d unpacked

          folder_name=$(jq .identifier unpacked/metadata.json --raw-output | tr . _)
          for d in unpacked/*; do
            if [ -d "$d" ]; then
              dest=$out/share/kicad/scripting/$(basename $d)/$folder_name
              mkdir -p $(dirname $dest)

              mv $d $dest
            fi
          done
          rm -r unpacked
        done
      '';

  inherit (lib)
    concatStringsSep
    flatten
    optionalString
    optionals
    ;
in
stdenv.mkDerivation rec {

  # Common libraries, referenced during runtime, via the wrapper.
  passthru.libraries = callPackages ./libraries.nix { inherit libSrc; };
  passthru.callPackage = newScope { inherit addonPath python3; };
  base = callPackage ./base.nix {
    inherit stable testing;
    inherit kicadSrc kicadVersion;
    inherit wxGTK python wxPython;
    inherit withNgspice withScripting withI18n;
    inherit debug sanitizeAddress sanitizeThreads;
  };

  inherit pname;
  version = if stable then kicadVersion else builtins.substring 0 10 src.src.rev;

  src = base;
  dontUnpack = true;
  dontConfigure = true;
  dontBuild = true;
  dontFixup = true;

  pythonPath =
    optionals withScripting [
      wxPython
      python.pkgs.six
      python.pkgs.requests
    ]
    ++ addonsDrvs;

  nativeBuildInputs = [ makeWrapper ] ++ optionals withScripting [ python.pkgs.wrapPython ];

  # KICAD7_TEMPLATE_DIR only works with a single path (it does not handle : separated paths)
  # but it's used to find both the templates and the symbol/footprint library tables
  # https://gitlab.com/kicad/code/kicad/-/issues/14792
  template_dir = symlinkJoin {
    name = "KiCad_template_dir";
    paths = with passthru.libraries; [
      "${templates}/share/kicad/template"
      "${footprints}/share/kicad/template"
      "${symbols}/share/kicad/template"
    ];
  };
  # We are emulating wrapGAppsHook3, along with other variables to the wrapper
  makeWrapperArgs =
    with passthru.libraries;
    [
      "--prefix XDG_DATA_DIRS : ${base}/share"
      "--prefix XDG_DATA_DIRS : ${hicolor-icon-theme}/share"
      "--prefix XDG_DATA_DIRS : ${adwaita-icon-theme}/share"
      "--prefix XDG_DATA_DIRS : ${gtk3}/share/gsettings-schemas/${gtk3.name}"
      "--prefix XDG_DATA_DIRS : ${gsettings-desktop-schemas}/share/gsettings-schemas/${gsettings-desktop-schemas.name}"
      # wrapGAppsHook3 did these two as well, no idea if it matters...
      "--prefix XDG_DATA_DIRS : ${cups}/share"
      "--prefix GIO_EXTRA_MODULES : ${dconf}/lib/gio/modules"
      # required to open a bug report link in firefox-wayland
      "--set-default MOZ_DBUS_REMOTE 1"
      "--set-default KICAD9_FOOTPRINT_DIR ${footprints}/share/kicad/footprints"
      "--set-default KICAD9_SYMBOL_DIR ${symbols}/share/kicad/symbols"
      "--set-default KICAD9_TEMPLATE_DIR ${template_dir}"
    ]
    ++ optionals (addons != [ ]) (
      let
        stockDataPath = symlinkJoin {
          name = "kicad_stock_data_path";
          paths = [
            "${base}/share/kicad"
            "${addonsJoined}/share/kicad"
          ];
        };
      in
      [ "--set-default NIX_KICAD9_STOCK_DATA_PATH ${stockDataPath}" ]
    )
    ++ optionals with3d [
      "--set-default KICAD9_3DMODEL_DIR ${packages3d}/share/kicad/3dmodels"
    ]
    ++ optionals withNgspice [ "--prefix LD_LIBRARY_PATH : ${libngspice}/lib" ]

    # infinisil's workaround for #39493
    ++ [ "--set GDK_PIXBUF_MODULE_FILE ${librsvg}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache" ];

  # why does $makeWrapperArgs have to be added explicitly?
  # $out and $program_PYTHONPATH don't exist when makeWrapperArgs gets set?
  installPhase =
    let
      bin = if stdenv.hostPlatform.isDarwin then "*.app/Contents/MacOS" else "bin";
      tools = [
        "kicad"
        "pcbnew"
        "eeschema"
        "gerbview"
        "pcb_calculator"
        "pl_editor"
        "bitmap2component"
        "kicad-cli"
      ];
      utils = [
        "dxf2idf"
        "idf2vrml"
        "idfcyl"
        "idfrect"
      ];
    in
    (concatStringsSep "\n" (flatten [
      "runHook preInstall"

      (optionalString withScripting "buildPythonPath \"${base} $pythonPath\" \n")

      # wrap each of the directly usable tools
      (map (
        tool:
        "makeWrapper ${base}/${bin}/${tool} $out/bin/${tool} $makeWrapperArgs"
        + optionalString withScripting " --set PYTHONPATH \"$program_PYTHONPATH\""
      ) tools)

      # link in the CLI utils
      (map (util: "ln -s ${base}/${bin}/${util} $out/bin/${util}") utils)

      "runHook postInstall"
    ]));

  postInstall = ''
    mkdir -p $out/share
    ln -s ${base}/share/applications $out/share/applications
    ln -s ${base}/share/icons $out/share/icons
    ln -s ${base}/share/mime $out/share/mime
    ln -s ${base}/share/metainfo $out/share/metainfo
  '';

  passthru.updateScript = {
    command = [
      ./update.sh
      "${pname}"
    ];
    supportedFeatures = [ "commit" ];
  };

  meta = {
    description =
      (
        if stable then
          "Open Source Electronics Design Automation suite"
        else if testing then
          "Open Source EDA suite, latest on stable branch"
        else
          "Open Source EDA suite, latest on master branch"
      )
      + (lib.optionalString (!with3d) ", without 3D models");
    homepage = "https://www.kicad.org/";
    longDescription = ''
      KiCad is an open source software suite for Electronic Design Automation.
      The Programs handle Schematic Capture, and PCB Layout with Gerber output.
    '';
    license = lib.licenses.gpl3Plus;
    maintainers = with lib.maintainers; [ korken89 ];
    platforms = lib.platforms.all;
    broken = stdenv.hostPlatform.isDarwin;
    mainProgram = "kicad";
  };
}
